import { defineStore } from 'pinia'
import { ref, computed, watch, onMounted } from 'vue'
import { getProducts, getCategories, searchProducts, createProduct, updateProduct as updateProductApi, publishProduct, unpublishProduct, deleteProduct as deleteProductApi } from '@/api/index.js'
import { getImageUrl } from '@/utils/imageHelper.js'

export const useProductsStore = defineStore('products', () => {
  // 商品数据
  const products = ref([])
  
  // 加载状态
  const loading = ref(false)
  
  // 错误信息
  const error = ref(null)
  
  // 分类加载状态
  const categoriesLoading = ref(false)
  
  // 分类错误信息
  const categoriesError = ref(null)
  
  // 分页信息
  const pagination = ref({
    page: 1,
    limit: 10,
    total: 0,
    pages: 0
  })
  
  // 排序信息
  const sortInfo = ref({
    sort: 'createTime',
    order: 'desc'
  })

  // 商品分类 - 现在设置为空数组，将通过API获取
  const categories = ref([])

  // 筛选条件
  const searchQuery = ref('')
  const categoryFilter = ref('')
  const statusFilter = ref('')
  
  // 选中商品
  const selectedProducts = ref([])

  // 搜索状态
  const isSearchMode = ref(false);
  const searchKeyword = ref('');
  const searchLoading = ref(false);
  const searchError = ref(null);

  // 添加商品的loading和error状态
  const addProductLoading = ref(false)
  const addProductError = ref(null)

  // 过滤后的商品
  const filteredProducts = computed(() => {
    // 如果在搜索模式下，直接返回产品列表，因为搜索结果已经从API获取
    if (isSearchMode.value) {
      return products.value;
    }
    
    return products.value.filter(product => {
      // 搜索条件
      const searchMatch = searchQuery.value === '' || 
        product.name.toLowerCase().includes(searchQuery.value.toLowerCase()) ||
        (product.id && product.id.toString().toLowerCase().includes(searchQuery.value.toLowerCase()))
      
      // 分类条件
      let categoryMatch = false;
      if (categoryFilter.value === '') {
        // 未选择分类，显示所有商品
        categoryMatch = true;
      } else {
        // 判断所选分类是否为父分类
        const selectedCategory = categories.value.find(c => c.id === categoryFilter.value);
        if (selectedCategory) {
          if (selectedCategory.parentId === null || selectedCategory.parentId === undefined) {
            // 是父分类，显示该父分类及其所有子分类的商品
            if (product.categoryId === categoryFilter.value) {
              // 直接属于该父分类
              categoryMatch = true;
            } else {
              // 检查是否属于该父分类的子分类
              const productCategory = categories.value.find(c => c.id === product.categoryId);
              categoryMatch = productCategory && productCategory.parentId === categoryFilter.value;
            }
          } else {
            // 是子分类，仅显示该子分类的商品
            categoryMatch = product.categoryId && product.categoryId.toString() === categoryFilter.value;
          }
        } else {
          // 找不到所选分类，使用简单匹配
          categoryMatch = product.categoryId && product.categoryId.toString() === categoryFilter.value;
        }
      }
      
      // 状态条件
      const statusMatch = statusFilter.value === '' || 
        (product.status !== undefined && product.status.toString() === statusFilter.value)
      
      return searchMatch && categoryMatch && statusMatch
    })
  })

  // 监听筛选条件变化，刷新数据
  watch([searchQuery, categoryFilter, statusFilter, pagination.value.page, sortInfo], () => {
    // 非搜索模式下才刷新商品列表
    if (!isSearchMode.value) {
      fetchProducts()
    }
  }, { deep: true })

  // 监听搜索关键词变化，触发搜索
  watch(searchKeyword, async (newKeyword) => {
    if (newKeyword.trim()) {
      await search(newKeyword);
    } else {
      // 关键词为空时退出搜索模式，恢复正常显示
      exitSearchMode();
    }
  }, { debounce: 500 }) // 添加500ms延迟，避免频繁搜索

  // 从API获取商品列表
  async function fetchProducts() {
    try {
      loading.value = true
      error.value = null
      
      const params = {
        page: pagination.value.page,
        limit: pagination.value.limit,
        sort: sortInfo.value.sort,
        order: sortInfo.value.order
      }
      
      // 添加筛选条件
      if (searchQuery.value) {
        params.keyword = searchQuery.value
      }
      
      if (categoryFilter.value) {
        // 直接使用选中的分类ID
        params.category = categoryFilter.value
      }
      
      const result = await getProducts(params)
      
      if (result.products) {
        // 更新商品列表和分页信息
        products.value = result.products.map(item => ({
          id: item._id, // API返回的ID字段是_id
          _id: item._id, // 保留原始MongoDB ID，用于API调用
          name: item.name,
          description: item.description,
          price: item.price,
          originalPrice: item.originalPrice,
          // 处理图片URL，确保使用后端地址
          image: item.images && item.images.length > 0 ? getImageUrl(item.images[0]) : '',
          stock: item.stock,
          sales: item.sales,
          status: item.status,
          categoryId: item.categoryId,
          createTime: item.createTime,
          updateTime: item.updateTime
        }))
        
        pagination.value.total = result.total || 0
        pagination.value.pages = result.pages || 0
        pagination.value.page = result.page || 1
      } else {
        error.value = '获取商品列表失败'
      }
    } catch (err) {
      console.error('获取商品列表错误:', err)
      error.value = err.message || '获取商品列表发生错误'
    } finally {
      loading.value = false
    }
  }
  
  // 从API获取分类列表
  async function fetchCategories() {
    try {
      categoriesLoading.value = true
      categoriesError.value = null
      
      // 不传parentId参数，获取所有分类
      const result = await getCategories()
      
      if (result.categories && Array.isArray(result.categories)) {
        // 将API返回的分类数据映射到应用需要的格式
        categories.value = result.categories.map(item => ({
          id: item._id,          // 使用API返回的_id作为分类ID
          name: item.name,       // 分类名称
          icon: item.icon,       // 分类图标
          sort: item.sort || 0,  // 排序权重，默认为0
          isActive: item.isActive, // 是否激活
          parentId: item.parentId  // 父分类ID
        }))
        
        // 对分类进行排序
        // 第一步：顶级分类按sort排序
        const topCategories = categories.value
          .filter(c => c.parentId === null || c.parentId === undefined)
          .sort((a, b) => a.sort - b.sort);
          
        // 第二步：子分类按parentId分组排序
        const childCategories = categories.value
          .filter(c => c.parentId !== null && c.parentId !== undefined);
          
        // 构建新的排序后的分类数组
        const sortedCategories = [];
        
        // 将顶级分类及其子分类添加到结果数组
        topCategories.forEach(parent => {
          // 添加父分类
          sortedCategories.push(parent);
          
          // 找到该父分类的所有子分类并按sort排序
          const children = childCategories
            .filter(c => c.parentId === parent.id)
            .sort((a, b) => a.sort - b.sort);
            
          // 将排序后的子分类添加到结果
          sortedCategories.push(...children);
        });
        
        // 更新分类数组
        categories.value = sortedCategories;
        
        console.log('获取到分类数据:', categories.value)
      } else {
        categoriesError.value = '获取分类列表失败'
        // 如果API获取失败，添加一些默认分类以确保界面不会崩溃
        resetToDefaultCategories()
      }
    } catch (err) {
      console.error('获取分类列表错误:', err)
      categoriesError.value = err.message || '获取分类列表发生错误'
      // 发生错误时，添加默认分类
      resetToDefaultCategories()
    } finally {
      categoriesLoading.value = false
    }
  }
  
  // 重置为默认分类（API请求失败时使用）
  function resetToDefaultCategories() {
    categories.value = [
      { id: '1', name: '手机数码', icon: '', sort: 1, isActive: true, parentId: null },
      { id: '2', name: '电脑办公', icon: '', sort: 2, isActive: true, parentId: null },
      { id: '3', name: '服装鞋包', icon: '', sort: 3, isActive: true, parentId: null },
      { id: '4', name: '食品生鲜', icon: '', sort: 4, isActive: true, parentId: null },
      { id: '5', name: '家居家装', icon: '', sort: 5, isActive: true, parentId: null }
    ]
  }

  // 获取分类名称
  function getCategoryName(categoryId) {
    const category = categories.value.find(c => c.id === categoryId)
    return category ? category.name : '-'
  }

  // 添加商品
  function addProduct(product) {
    try {
      // 生成新的商品ID
      const newId = 'P' + String(products.value.length + 1).padStart(3, '0')
      
      const newProduct = {
        id: newId,
        name: product.name,
        price: parseFloat(product.price),
        originalPrice: product.originalPrice ? parseFloat(product.originalPrice) : null,
        stock: parseInt(product.stock),
        categoryId: product.categoryId,
        // 确保图片URL使用后端地址
        image: product.images && product.images.length > 0 
          ? getImageUrl(typeof product.images[0] === 'string' ? product.images[0] : URL.createObjectURL(product.images[0]))
          : getImageUrl(product.image) || '',
        description: product.description,
        detail: product.detail || '',
        tags: product.tags || [],
        specs: product.specs || [],
        status: parseInt(product.status),
        sales: 0
      }
      
      // 添加到商品列表
      products.value.push(newProduct)
      
      // 添加完商品后刷新数据，确保与服务器同步
      setTimeout(() => {
        fetchProducts()
      }, 1000) // 延迟1秒后刷新，确保API端已处理完请求
      
      return newProduct
    } catch (error) {
      console.error('添加商品错误:', error)
      return null
    }
  }

  // 更新商品
  function updateProduct(product) {
    const index = products.value.findIndex(p => p.id === product.id)
    if (index !== -1) {
      products.value[index] = { 
        ...products.value[index],
        name: product.name,
        price: parseFloat(product.price),
        originalPrice: product.originalPrice ? parseFloat(product.originalPrice) : null,
        stock: parseInt(product.stock),
        categoryId: product.categoryId,
        // 确保图片URL使用后端地址
        image: getImageUrl(product.image),
        description: product.description,
        status: parseInt(product.status)
      }
      
      // 延迟刷新数据
      setTimeout(() => {
        fetchProducts()
      }, 1000)
      
      return true
    }
    return false
  }

  // 使用API更新商品信息
  async function updateProductWithApi(productId, productData) {
    try {
      addProductLoading.value = true;
      addProductError.value = null;
      
      // 确保使用原始MongoDB _id格式的商品ID
      let realProductId = productId;
      
      // 如果这是一个对象，可能包含_id字段
      if (typeof productId === 'object' && productId._id) {
        realProductId = productId._id;
      } 
      // 如果这是一个ID字符串，在产品列表中查找对应的_id
      else if (productId) {
        const product = products.value.find(p => p.id === productId);
        if (product && product._id) {
          realProductId = product._id; // 使用后端返回的_id
        }
      }
      
      if (!realProductId) {
        throw new Error('无法确定商品ID，更新失败');
      }
      
      // 调用API更新商品，使用正确的ID格式
      const result = await updateProductApi(realProductId, productData);
      
      if (result && result.product) {
        // 刷新商品列表，确保数据同步
        await fetchProducts();
        
        return {
          success: true,
          product: result.product,
          message: result.message || '商品更新成功'
        };
      } else {
        throw new Error('更新商品失败，服务器返回数据格式不正确');
      }
    } catch (err) {
      console.error('更新商品错误:', err);
      addProductError.value = err.message || '更新商品时发生错误';
      
      return {
        success: false,
        message: addProductError.value
      };
    } finally {
      addProductLoading.value = false;
    }
  }

  // 修改删除商品的函数，使用API
  async function deleteProduct(productId) {
    try {
      loading.value = true;
      error.value = null;
      
      // 调用API删除商品
      const result = await deleteProductApi(productId);
      
      if (result.success) {
        // 删除成功，从本地列表中移除
        const index = products.value.findIndex(p => p.id === productId || p._id === productId);
        if (index !== -1) {
          products.value.splice(index, 1);
          
          // 如果该商品在选中列表中，也从选中列表中移除
          const selectedIndex = selectedProducts.value.indexOf(productId);
          if (selectedIndex !== -1) {
            selectedProducts.value.splice(selectedIndex, 1);
          }
        }
        
        // 刷新商品列表
        await fetchProducts();
        return {
          success: true,
          message: result.message || '商品删除成功'
        };
      } else {
        error.value = result.message || '删除商品失败';
        return {
          success: false,
          message: error.value
        };
      }
    } catch (err) {
      console.error('删除商品错误:', err);
      error.value = err.message || '删除商品时发生错误';
      return {
        success: false,
        message: error.value
      };
    } finally {
      loading.value = false;
    }
  }

  // 批量更新商品状态
  function batchUpdateStatus(status) {
    if (selectedProducts.value.length === 0) return false
    
    // 更新选中商品的状态
    products.value.forEach(p => {
      if (selectedProducts.value.includes(p.id)) {
        p.status = status
      }
    })
    
    // 延迟刷新数据
    setTimeout(() => {
      fetchProducts()
    }, 1000)
    
    return true
  }

  // 批量删除商品
  async function batchDeleteProducts() {
    if (selectedProducts.value.length === 0) {
      return {
        success: false,
        message: '没有选中任何商品'
      };
    }
    
    try {
      loading.value = true;
      error.value = null;
      
      // 记录成功和失败数量
      let successCount = 0;
      let failCount = 0;
      
      // 逐个调用删除API
      for (const productId of selectedProducts.value) {
        const result = await deleteProductApi(productId);
        if (result.success) {
          successCount++;
        } else {
          failCount++;
        }
      }
      
      // 清空选中
      selectedProducts.value = [];
      
      // 刷新商品列表
      await fetchProducts();
      
      // 根据结果返回信息
      if (failCount === 0) {
        return {
          success: true,
          message: `成功删除 ${successCount} 个商品`
        };
      } else {
        return {
          success: true,
          message: `成功删除 ${successCount} 个商品，${failCount} 个删除失败`
        };
      }
    } catch (err) {
      console.error('批量删除商品错误:', err);
      error.value = err.message || '批量删除商品时发生错误';
      return {
        success: false,
        message: error.value
      };
    } finally {
      loading.value = false;
    }
  }

  // 切换商品状态
  function toggleProductStatus(productId) {
    const product = products.value.find(p => p.id === productId)
    if (product) {
      product.status = product.status === 1 ? 0 : 1
      
      // 延迟刷新数据
      setTimeout(() => {
        fetchProducts()
      }, 1000)
      
      return true
    }
    return false
  }

  // 设置页码
  function setPage(page) {
    pagination.value.page = page
  }

  // 设置每页显示数量
  function setLimit(limit) {
    pagination.value.limit = limit
    pagination.value.page = 1 // 重置页码
  }

  // 设置排序
  function setSort(sort, order = 'desc') {
    sortInfo.value.sort = sort
    sortInfo.value.order = order
  }

  // 初始化获取数据
  function init() {
    fetchCategories()
    fetchProducts()
  }

  // 执行搜索
  async function search(keyword) {
    if (!keyword.trim()) {
      exitSearchMode();
      return;
    }
    
    try {
      isSearchMode.value = true;
      searchLoading.value = true;
      searchError.value = null;
      
      const params = {
        keyword: keyword,
        page: pagination.value.page,
        limit: pagination.value.limit,
        sort: sortInfo.value.sort,
        order: sortInfo.value.order
      };
      
      // 添加分类筛选（如果有）
      if (categoryFilter.value) {
        params.category = categoryFilter.value;
      }
      
      // 添加状态筛选（如果有）
      if (statusFilter.value) {
        params.status = statusFilter.value;
      }
      
      const result = await searchProducts(params);
      
      if (result.products) {
        // 更新商品列表和分页信息
        products.value = result.products.map(item => ({
          id: item._id, // API返回的ID字段是_id
          _id: item._id, // 保留原始MongoDB ID，用于API调用
          name: item.name,
          description: item.description,
          price: item.price,
          originalPrice: item.originalPrice,
          // 处理图片URL，确保使用后端地址
          image: item.images && item.images.length > 0 ? getImageUrl(item.images[0]) : '',
          stock: item.stock,
          sales: item.sales,
          status: item.status,
          categoryId: item.categoryId,
          createTime: item.createTime,
          updateTime: item.updateTime
        }));
        
        pagination.value.total = result.total || 0;
        pagination.value.pages = result.pages || 0;
        pagination.value.page = result.page || 1;
      } else {
        searchError.value = '搜索结果为空';
        products.value = []; // 清空商品列表
      }
    } catch (err) {
      console.error('搜索商品错误:', err);
      searchError.value = err.message || '搜索商品发生错误';
      products.value = []; // 清空商品列表
    } finally {
      searchLoading.value = false;
    }
  }
  
  // 退出搜索模式
  function exitSearchMode() {
    isSearchMode.value = false;
    searchKeyword.value = '';
    searchError.value = null;
    // 恢复正常加载
    fetchProducts();
  }

  // 创建新商品
  async function addNewProduct(productData) {
    try {
      addProductLoading.value = true
      addProductError.value = null
      
      // 调用API创建商品
      const result = await createProduct(productData)
      
      if (result && result.product) {
        // 格式化添加的商品数据
        const newProduct = {
          id: result.product._id,
          _id: result.product._id, // 保留原始MongoDB ID，用于API调用
          name: result.product.name,
          description: result.product.description,
          price: parseFloat(result.product.price),
          originalPrice: result.product.originalPrice ? parseFloat(result.product.originalPrice) : null,
          // 处理图片URL，确保使用后端地址
          image: result.product.images && result.product.images.length > 0 ? getImageUrl(result.product.images[0]) : '',
          images: result.product.images ? result.product.images.map(img => getImageUrl(img)) : [],
          stock: parseInt(result.product.stock),
          categoryId: result.product.categoryId,
          detail: result.product.detail || '',
          tags: result.product.tags || [],
          specs: result.product.specs || [],
          status: parseInt(result.product.status),
          sales: 0,
          createTime: result.product.createTime,
          updateTime: result.product.updateTime
        }
        
        // 刷新商品列表
        await fetchProducts()
        
        return {
          success: true,
          product: newProduct,
          message: result.message || '商品添加成功'
        }
      } else {
        throw new Error('创建商品失败，服务器返回数据格式不正确')
      }
    } catch (err) {
      console.error('创建商品错误:', err)
      addProductError.value = err.message || '创建商品发生错误'
      
      return {
        success: false,
        message: addProductError.value
      }
    } finally {
      addProductLoading.value = false
    }
  }

  // 将商品上架
  async function publishProductApi(productId) {
    try {
      addProductLoading.value = true;
      addProductError.value = null;
      
      // 确保使用原始MongoDB _id格式的商品ID
      let realProductId = productId;
      
      // 如果这是一个对象，可能包含_id字段
      if (typeof productId === 'object' && productId._id) {
        realProductId = productId._id;
      } 
      // 如果这是一个ID字符串，在产品列表中查找对应的_id
      else if (productId) {
        const product = products.value.find(p => p.id === productId || p._id === productId);
        if (product && product._id) {
          realProductId = product._id; // 使用后端返回的_id
        }
      }
      
      if (!realProductId) {
        throw new Error('无法确定商品ID，上架失败');
      }

      console.log(`尝试上架商品，使用ID: ${realProductId}`);
      
      // 调用API上架商品，确保提供空对象作为请求体
      const result = await publishProduct(realProductId);
      
      console.log('上架商品API返回结果:', result);
      
      // 更广泛的成功检测
      if (result.success) {
        // 刷新商品列表，确保数据同步
        await fetchProducts();
        
        return {
          success: true,
          product: result.product,
          message: result.message || '商品上架成功'
        };
      } else {
        return {
          success: false,
          message: result.message || '上架商品失败'
        };
      }
    } catch (err) {
      console.error('上架商品错误:', err);
      addProductError.value = err.message || '上架商品时发生错误';
      
      return {
        success: false,
        message: addProductError.value
      };
    } finally {
      addProductLoading.value = false;
    }
  }

  // 将商品下架
  async function unpublishProductApi(productId) {
    try {
      addProductLoading.value = true;
      addProductError.value = null;
      
      // 确保使用原始MongoDB _id格式的商品ID
      let realProductId = productId;
      
      // 如果这是一个对象，可能包含_id字段
      if (typeof productId === 'object' && productId._id) {
        realProductId = productId._id;
      } 
      // 如果这是一个ID字符串，在产品列表中查找对应的_id
      else if (productId) {
        const product = products.value.find(p => p.id === productId || p._id === productId);
        if (product && product._id) {
          realProductId = product._id; // 使用后端返回的_id
        }
      }
      
      if (!realProductId) {
        throw new Error('无法确定商品ID，下架失败');
      }

      console.log(`尝试下架商品，使用ID: ${realProductId}`);
      
      // 调用API下架商品，确保提供空对象作为请求体
      const result = await unpublishProduct(realProductId);
      
      console.log('下架商品API返回结果:', result);
      
      // 更广泛的成功检测
      if (result.success) {
        // 刷新商品列表，确保数据同步
        await fetchProducts();
        
        return {
          success: true,
          product: result.product,
          message: result.message || '商品下架成功'
        };
      } else {
        return {
          success: false,
          message: result.message || '下架商品失败'
        };
      }
    } catch (err) {
      console.error('下架商品错误:', err);
      addProductError.value = err.message || '下架商品时发生错误';
      
      return {
        success: false,
        message: addProductError.value
      };
    } finally {
      addProductLoading.value = false;
    }
  }

  // 批量上架商品
  async function batchPublishProducts() {
    if (selectedProducts.value.length === 0) return false;
    
    try {
      // 为每个商品调用上架API
      let successCount = 0;
      let failCount = 0;
      
      for (const productId of selectedProducts.value) {
        const product = products.value.find(p => p.id === productId);
        if (product) {
          try {
            const result = await publishProductApi(product._id || product.id);
            if (result.success) {
              successCount++;
            } else {
              failCount++;
            }
          } catch (err) {
            console.error(`上架商品 ${productId} 失败:`, err);
            failCount++;
          }
        }
      }
      
      // 刷新商品列表
      await fetchProducts();
      
      return {
        success: successCount > 0,
        message: `成功上架 ${successCount} 个商品${failCount > 0 ? `，${failCount} 个商品上架失败` : ''}`,
        successCount,
        failCount
      };
    } catch (err) {
      console.error('批量上架商品错误:', err);
      return {
        success: false,
        message: err.message || '批量上架商品时发生错误'
      };
    }
  }
  
  // 批量下架商品
  async function batchUnpublishProducts() {
    if (selectedProducts.value.length === 0) return false;
    
    try {
      // 为每个商品调用下架API
      let successCount = 0;
      let failCount = 0;
      
      for (const productId of selectedProducts.value) {
        const product = products.value.find(p => p.id === productId);
        if (product) {
          try {
            const result = await unpublishProductApi(product._id || product.id);
            if (result.success) {
              successCount++;
            } else {
              failCount++;
            }
          } catch (err) {
            console.error(`下架商品 ${productId} 失败:`, err);
            failCount++;
          }
        }
      }
      
      // 刷新商品列表
      await fetchProducts();
      
      return {
        success: successCount > 0,
        message: `成功下架 ${successCount} 个商品${failCount > 0 ? `，${failCount} 个商品下架失败` : ''}`,
        successCount,
        failCount
      };
    } catch (err) {
      console.error('批量下架商品错误:', err);
      return {
        success: false,
        message: err.message || '批量下架商品时发生错误'
      };
    }
  }

  return {
    products,
    categories,
    searchQuery,
    categoryFilter,
    statusFilter,
    selectedProducts,
    filteredProducts,
    pagination,
    sortInfo,
    loading,
    error,
    categoriesLoading,
    categoriesError,
    // 搜索相关
    isSearchMode,
    searchKeyword,
    searchLoading,
    searchError,
    search,
    exitSearchMode,
    getCategoryName,
    addProduct,
    updateProduct,
    deleteProduct,
    batchUpdateStatus,
    batchDeleteProducts,
    toggleProductStatus,
    fetchProducts,
    fetchCategories,
    setPage,
    setLimit,
    setSort,
    init,
    addProductLoading,
    addProductError,
    addNewProduct,
    updateProductWithApi,
    publishProductApi,
    unpublishProductApi,
    batchPublishProducts,
    batchUnpublishProducts
  }
}, {
  persist: {
    // 只持久化分类和筛选条件，不持久化商品数据
    paths: ['categoryFilter', 'statusFilter', 'searchQuery', 'sortInfo', 'pagination'],
  }
})